package com.ylzinfo.jck.services;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.lbs.brick.util.BeanHelper;
import com.ylzinfo.jck.domain.*;
import com.ylzinfo.jck.service.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;

import javax.jws.WebService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @description 基础库WebService接口
 * @author sunqy
 * @date 2019/11/19
 */
@WebService(
        serviceName = "jckServer",
        targetNamespace = "http://www.ylzinfo.com"
)
public class JckWSImpl implements JckWS {

    private Logger logger = LoggerFactory.getLogger(JckWSImpl.class);

    @Autowired
    private Ac01Service ac01Service;

    @Autowired
    private Ac01aService ac01aService;

    @Autowired
    private Ac02aService ac02aService;

    @Autowired
    private Ab01Service ab01Service;

    @Autowired
    private Ab01aService ab01aService;

    /**
     * 根据aac002查询ac01
     * @param instr "aac002":"370828198106025610"
     * @return 调用接口拿到结果后先判断code，为1才能获取到人员信息
     *         code=1代表成功，=0代表失败；
     *         msg代表返回成功或失败提醒信息；
     *         perInfo代表成功时返回的数据
     */
    @Override
    public String getPerinfoByAac002(String instr) {
        Map<String, String> outMap = new HashMap<>();
        String aac002;
        try {
            Map<String, Object> inMap = new HashMap<>();
            if (!StringUtils.isEmpty(instr)) {
                inMap = JSONObject.parseObject(instr);
            }
            // 入参为空
            if (inMap.size() <= 0) {
                outMap.put("code", "2");
                outMap.put("msg", "获取人员信息失败，入参不能为空！");
                return JSONObject.toJSONString(outMap);
            }
            aac002 = (String) inMap.get("aac002");
            if (StringUtils.isEmpty(aac002)) {
                outMap.put("code", "2");
                outMap.put("msg", "获取人员信息失败，传入的aac002不能为空！");
                return JSONObject.toJSONString(outMap);
            }
            Ac01 ac01 = ac01Service.queryByAac002(aac002);
            if (ac01 == null) {
                outMap.put("code", "0");
                outMap.put("msg", "获取人员信息失败，找不到社会保障号为" + aac002 + "对应的人员信息！");
                return JSONObject.toJSONString(outMap);
            }
            outMap.put("data", JSON.toJSONString(ac01));
            outMap.put("code", "1");
            outMap.put("msg", "获取人员信息成功！");
        } catch (Exception e) {
            outMap.put("code", "2");
            outMap.put("msg", "获取人员信息失败，" + e.getMessage() + ",请联系管理员！");
        }
        return JSONObject.toJSONString(outMap);
    }

    /**
     * 新增或修改人员基本信息（单个），插入到临时表AC01A，不做业务判断直接插入
     * @param instr perInfo： 人员信息
     * @return outMap
     *         code=1代表成功 =0代表失败
     *         msg 代表返回成功或失败提醒信息
     */
    @Override
    public String addOrModPerson(String instr) {
        Map<String, String> outMap = new HashMap<>();
        try {
            Map<String, Object> inMap = new HashMap<>();
            if (!StringUtils.isEmpty(instr)) {
                inMap = JSONObject.parseObject(instr);
            }
            //获取人员信息并校验
            JSONObject ac01aObj = (JSONObject) inMap.get("perInfo");
            if (ac01aObj == null || ac01aObj.size() == 0) {
                outMap.put("code", "2");
                outMap.put("msg", "单个更新人员信息失败，传入的人员信息不能为空！");
                return JSONObject.toJSONString(outMap);
            }
            //设值
            Ac01A ac01A = new Ac01A();
            BeanHelper.copyProperties(ac01aObj, ac01A);
            //调用service层处理，插入ac01a   返回成功数量
            int resultCount = ac01aService.addAc01A(ac01A);
            if (resultCount == 1) {
                outMap.put("code", "1");
                outMap.put("msg", "更新人员信息成功！");
            } else {
                outMap.put("code", "2");
                outMap.put("msg", "单个更新人员信息失败，请联系管理员！");
            }
        } catch (Exception e) {
            logger.error("{}", e);
            outMap.put("code", "2");
            outMap.put("msg", "单个更新人员信息失败，" + e.getMessage() + ",请联系管理员！");
        }
        return JSONObject.toJSONString(outMap);
    }

    /**
     * 批量新增或修改人员基本信息，插入到临时表AC01A，不做业务判断直接插入。成功则全部成功，失败则全部失败
     * @param instr perInfos： 人员信息list
     * @return outMap
     *         code=1代表成功 =0代表失败
     *         msg 代表返回成功或失败提醒信息
     */
    @Override
    public String batchAddOrModPerson(String instr) {
        logger.info("batchAddOrModPerson");
        Map<String, String> outMap = new HashMap<>();
        try {
            Map<String, Object> inMap = new HashMap<>();
            if (!StringUtils.isEmpty(instr)) {
                inMap = JSONObject.parseObject(instr);
            }
            List list = (List) inMap.get("perInfos");
            if (list.size() <= 0) {
                outMap.put("code", "2");
                outMap.put("msg", "批量更新人员信息失败，传入的人员信息不能为空！");
                return JSONObject.toJSONString(outMap);
            }
            //拼装list，因为原list不是Ac01a的泛型
            List<Ac01A> ac01AList = new ArrayList<>();
            for (Object obj : list) {
                Ac01A ac01A = new Ac01A();
                BeanHelper.copyProperties(obj, ac01A);
                ac01A.setState("0");
                ac01AList.add(ac01A);
            }
            //调用service层处理，插入ac01a   返回成功数量
            int resultCount = ac01aService.addAc01As(ac01AList);
            if (resultCount == ac01AList.size()) {
                outMap.put("code", "1");
                outMap.put("msg", "批量更新人员信息成功！");
            } else {
                outMap.put("code", "2");
                outMap.put("msg", "批量更新人员信息存在失败，请联系管理员！");
            }
        } catch (Exception e) {
            logger.error("{}", e);
            outMap.put("code", "2");
            outMap.put("msg", "批量更新人员信息失败，" + e.getMessage() + ",请联系管理员！");
        }
        return JSONObject.toJSONString(outMap);
    }

    /**
     * 新增或修改人员参保信息
     * @param instr 入参为ac02a实体其中有aac002
     * @return
     */
    @Override
    public String addOrModPerInsure(String instr) {
        Map<String, String> outMap = new HashMap<>();
        try {
            Map<String, Object> inMap = new HashMap<>();
            if (!StringUtils.isEmpty(instr)) {
                inMap = JSONObject.parseObject(instr);
            }
            JSONObject ac02aObj = (JSONObject) inMap.get("perInsureInfo");
            if (ac02aObj == null || ac02aObj.size() == 0) {
                outMap.put("code", "2");
                outMap.put("msg", "传入的人员参保信息不能为空！");
                return JSONObject.toJSONString(outMap);
            }
            Ac02A ac02A = new Ac02A();
            BeanHelper.copyProperties(ac02aObj, ac02A);
            if (StringUtils.isEmpty(ac02A.getAac002())) {
                outMap.put("code", "2");
                outMap.put("msg", "传入的人员参保信息中必须含有社会保障号aac002字段！");
                return JSONObject.toJSONString(outMap);
            }
            //调用service层处理，插入ac02a   成功返回true
            int resultCount = ac02aService.addAc02A(ac02A);
            if (resultCount == 1) {
                outMap.put("code", "1");
                outMap.put("msg", "更新人员参保信息成功！");
            } else if (resultCount == -2) {
                outMap.put("code", "2");
                outMap.put("msg", "更新人员参保信息失败，未找到aac002对应的人员基本信息！");
            } else {
                outMap.put("code", "2");
                outMap.put("msg", "更新人员参保信息失败，请联系管理员！");
            }
        } catch (Exception e) {
            logger.error("{}", e);
            outMap.put("code", "2");
            outMap.put("msg", "更新人员参保信息失败，" + e.getMessage() + ",请联系管理员！");
        }
        return JSONObject.toJSONString(outMap);
    }

    /**
     * 批量新增或修改人员参保信息
     * @param instr
     * @return
     */
    @Override
    public String batchAddOrModPerInsure(String instr) {
        logger.info("batchAddOrModPerInsure");
        Map<String, String> outMap = new HashMap<>();
        try {
            Map<String, Object> inMap = new HashMap<>();
            if (!StringUtils.isEmpty(instr)) {
                inMap = JSONObject.parseObject(instr);
            }
            List list = (List) inMap.get("perInsureInfos");
            if (list.size() <= 0) {
                outMap.put("code", "2");
                outMap.put("msg", "批量更新人员参保信息失败，传入的人员参保信息不能为空！");
                return JSONObject.toJSONString(outMap);
            }
            //拼装list，因为原list不是Ac02a的泛型
            List<Ac02A> ac02AList = new ArrayList<>();
            for (Object obj : list) {
                Ac02A ac02A = new Ac02A();
                BeanHelper.copyProperties(obj, ac02A);
                ac02A.setState("0");
                ac02AList.add(ac02A);
            }
            //调用service层处理，插入ac02a   返回成功数量
            int resultCount = ac02aService.addAc02As(ac02AList);
            if (resultCount == ac02AList.size()) {
                outMap.put("code", "1");
                outMap.put("msg", "批量更新人员参保信息成功！");
            } else {
                outMap.put("code", "2");
                outMap.put("msg", "批量更新人员参保信息存在失败，请联系管理员！");
            }
        } catch (Exception e) {
            logger.error("{}", e);
            outMap.put("code", "2");
            outMap.put("msg", "批量更新人员参保信息失败，" + e.getMessage() + ",请联系管理员！");
        }
        return JSONObject.toJSONString(outMap);
    }

    /**
     * 通过单位名称获取单位信息
     * @param instr "aab003" : "###"
     * @return code=1代表成功， =0代表失败；
     *         msg 代表返回成功或失败提醒信息；
     *         comInfo 代表成功时返回的数据
     */
    @Override
    public String getCompanyInfoByAab003(String instr) {
        Map<String, String> outMap = new HashMap<>();
        String aab003 = "";
        try {
            Map<String, Object> inMap = new HashMap<>();
            if (!StringUtils.isEmpty(instr)) {
                inMap = JSONObject.parseObject(instr);
            }
            if (inMap.size() <= 0) {
                outMap.put("code", "2");
                outMap.put("msg", "获取单位信息失败，入参不能为空！");
                return JSONObject.toJSONString(outMap);
            }
            aab003 = inMap.get("aab003").toString();
            if (StringUtils.isEmpty(aab003)) {
                outMap.put("code", "2");
                outMap.put("msg", "获取单位信息失败，传入的统一社会信用代码aab003不能为空！");
                return JSONObject.toJSONString(outMap);
            }
            Ab01 ab01 = ab01Service.queryByAab003(aab003);
            if (ab01 == null) {
                outMap.put("code", "0");
                outMap.put("msg", "获取单位信息失败，找不到统一社会信用代码为[" + aab003 + "]对应的单位信息！");
                return JSONObject.toJSONString(outMap);
            }
            outMap.put("data", JSON.toJSONString(ab01));
            outMap.put("code", "1");
            outMap.put("msg", "获取单位信息成功！");
        } catch (Exception e) {
            logger.error("{}", e);
            outMap.put("code", "2");
            outMap.put("msg", "获取单位信息失败，" + e.getMessage() + "请联系管理员！");
        }
        logger.info("aab003:{}", aab003);
        return JSONObject.toJSONString(outMap);
    }

    /**
     * 新增或修改单位基本信息
     * @param instr
     * @return code=1代表成功， =0代表失败；
     *         msg 代表返回成功或失败提醒信息；
     * @throws Exception
     */
    @Override
    public String addOrModCompany(String instr) throws Exception {
        Map<String, String> outMap = new HashMap<>();
        try {
            Map<String, Object> inMap = new HashMap<>();
            if (!StringUtils.isEmpty(instr)) {
                inMap = JSONObject.parseObject(instr);
            }
            JSONObject ab01aObj = (JSONObject) inMap.get("comInfo");
            if (ab01aObj == null || ab01aObj.size() == 0) {
                outMap.put("code", "2");
                outMap.put("msg", "传入的单位信息不能为空！");
                return JSONObject.toJSONString(outMap);
            }
            Ab01A ab01A = new Ab01A();
            BeanHelper.copyProperties(ab01aObj, ab01A);
            //调用service层处理，插入ab01a   返回成功数
            int resultCount = ab01aService.addAb01A(ab01A);
            if (resultCount == 1) {
                outMap.put("code", "1");
                outMap.put("msg", "更新单位信息成功！");
            } else {
                outMap.put("code", "2");
                outMap.put("msg", "更新单位信息失败，请联系管理员！");
            }
        } catch (Exception e) {
            logger.error("{}", e);
            outMap.put("code", "2");
            outMap.put("msg", "更新单位信息失败，" + e.getMessage() + ",请联系管理员！");
        }
        return JSONObject.toJSONString(outMap);
    }

    /**
     * 批量新增或修改单位信息
     * @param instr
     * @return
     */
    @Override
    public String batchAddOrModCompany(String instr) {
        logger.info("batchAddOrModCompany");
        Map<String, String> outMap = new HashMap<>();
        try {
            Map<String, Object> inMap = new HashMap<>();
            if (!StringUtils.isEmpty(instr)) {
                inMap = JSONObject.parseObject(instr);
            }
            List list = (List) inMap.get("comInfos");
            if (list.size() <= 0) {
                outMap.put("code", "2");
                outMap.put("msg", "批量更新单位信息失败，传入的单位信息不能为空！");
                return JSONObject.toJSONString(outMap);
            }
            //拼装list，因为原list不是Ab01a的泛型
            List<Ab01A> ab01AList = new ArrayList<>();
            for (Object obj : list) {
                Ab01A ab01A = new Ab01A();
                BeanHelper.copyProperties(obj, ab01A);
                ab01A.setState("0");
                ab01AList.add(ab01A);
            }
            //调用service层处理，插入ac02a   返回成功数量
            int resultCount = ab01aService.addAb01As(ab01AList);
            if (resultCount == ab01AList.size()) {
                outMap.put("code", "1");
                outMap.put("msg", "批量更新单位信息成功！");
            } else {
                outMap.put("code", "2");
                outMap.put("msg", "批量更新单位信息存在失败，请联系管理员！");
            }
        } catch (Exception e) {
            logger.error("{}", e);
            outMap.put("code", "2");
            outMap.put("msg", "批量更新单位信息失败，" + e.getMessage() + ",请联系管理员！");
        }
        return JSONObject.toJSONString(outMap);
    }

}
